/**
 * 
 */
package persistence.DAO.SQL.entities;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import metier.Bean;
import metier.Utilisateur;

import org.apache.log4j.Logger;

import persistence.ConnectionManager;
import persistence.DAO.DAO;
import persistence.DAO.DAOSQL;

/**
 * @author hozakan
 *
 */
public class DAOSQLUtilisateur extends DAOSQL {

	private static DAO instance;
	private static final Logger LOGGER = Logger.getLogger(DAOSQLUtilisateur.class);
	private PreparedStatement verify;
	
	public static DAO getInstance() {
		if (instance == null)
			instance = new DAOSQLUtilisateur();
		return instance;
	}
	
	private DAOSQLUtilisateur() {
		try {
			insert = prepareInsert();
			update = prepareUpdate();
			delete = prepareDelete();
			select = prepareSelect();
		    selectAll = prepareSelectAll();	
		    verify = prepareVerif();
		} catch (Exception e) {
			LOGGER.error("Erreur lors de la création des PreparedStatement");
		}
	}

	@Override
	public boolean effacer(Bean bean) {
		boolean retour = false;
		try {
			ConnectionManager.getInstance().getConnection();
			delete.clearParameters();
			delete.setInt(1, bean.getId());
			delete.executeUpdate();
			retour = true;
		} catch (SQLException e) {
			LOGGER.error("Erreur lors de la modification d'un article");
		} catch (ClassNotFoundException e) {
			LOGGER.error("Impossible d'obtenir la connexion");
		}		
		return retour;
	}

	/**
	 * Enregistre le bean. Si le bean n'a pas d'id alors il est créé, sinon il est updaté.
	 */
	@Override
	public boolean enregistrer(Bean bean) throws Exception {
		boolean done = false;
		ConnectionManager.getInstance().getConnection();
		if (bean.getId() == 0) {
			done = create(bean);
		} else {
			done = update(bean);
		}
		return done;
	}

	private boolean update(Bean bean) {
		boolean retour = false;
		Utilisateur user = (Utilisateur) bean;
		try {
			ConnectionManager.getInstance().getConnection();
			update.clearParameters();
			update.setString(1, user.getLogin());
			update.setString(2, user.getPassword());
			update.setString(3, user.getNom());
			update.setString(4, user.getPrenom());
			update.setDate(5, new java.sql.Date(new java.util.Date().getTime()));
			update.setString(6, user.getEmail());
			update.setString(7, user.getNewsletter());
			update.setString(8, user.getRang());
			update.setInt(9, user.getId());
			update.executeUpdate();
			retour = true;
		} catch (SQLException e) {
			LOGGER.error("Erreur lors de la modification d'un article");
		} catch (ClassNotFoundException e) {
			LOGGER.error("Impossible d'obtenir la connexion");
		}		
		return retour;
	}

	private boolean create(Bean bean) {
		boolean retour = false;
		Utilisateur user = (Utilisateur) bean;
		try {
			ConnectionManager.getInstance().getConnection();
			insert.clearParameters();
			insert.setString(1, user.getLogin());
			insert.setString(2, user.getPassword());
			insert.setString(3, user.getNom());
			insert.setString(4, user.getPrenom());
			insert.setDate(5, new java.sql.Date(new java.util.Date().getTime()));
			insert.setString(6, user.getEmail());
			insert.setString(7, user.getNewsletter());
			insert.setString(8, user.getRang());
			insert.executeUpdate();
			retour = true;
		} catch (SQLException e) {
			LOGGER.error("Erreur lors de la modification d'un article");
		} catch (ClassNotFoundException e) {
			LOGGER.error("Impossible d'obtenir la connexion");
		}		
		return retour;
	}

	@Override
	protected PreparedStatement prepareDelete() throws SQLException, ClassNotFoundException {
		PreparedStatement ps = null;
		ps = ConnectionManager.getInstance().getConnection().prepareStatement("DELETE FROM utilisateur WHERE idUtilisateur=?");
		return ps;
	}

	@Override
	protected PreparedStatement prepareInsert() throws SQLException, ClassNotFoundException {
		PreparedStatement ps = null;
		ps = ConnectionManager.getInstance().getConnection().prepareStatement("INSERT INTO utilisateur " +
				"(login, password, nom, prenom, dateDeNaissance, email, newsletter, rang) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
		return ps;
	}

	@Override
	protected PreparedStatement prepareUpdate() throws SQLException, ClassNotFoundException {
		PreparedStatement ps = null;
		ps = ConnectionManager.getInstance().getConnection().prepareStatement("UPDATE utilisateur SET " +
				"login=?, password=?, nom=?, prenom=?, dateDeNaissance=?, email=?, newsletter=?, rang=? WHERE idUtilisateur=?");
		return ps;
	}

	/*__________________________________________________________*/
	/**
	 * @return
	 * @throws SQLException
	 * @throws ClassNotFoundException
	 * @see persistence.DAO.DAOSQL#prepareSelect()
	 */
	@Override
	protected PreparedStatement prepareSelect() throws SQLException,
			ClassNotFoundException
	{
		PreparedStatement ps = null;
		ps = ConnectionManager.getInstance().getConnection().prepareStatement("SELECT * FROM utilisateur WHERE idUtilisateur=?");
		return ps;
	}

	/*__________________________________________________________*/
	/**
	 * @return
	 * @throws SQLException
	 * @throws ClassNotFoundException
	 * @see persistence.DAO.DAOSQL#prepareSelectAll()
	 */
	@Override
	protected PreparedStatement prepareSelectAll() throws SQLException,
			ClassNotFoundException
			{
				PreparedStatement ps = null;
				ps = ConnectionManager.getInstance().getConnection().prepareStatement("SELECT * FROM utilisateur");
				return ps;
			}

	/*__________________________________________________________*/
	/**
	 * @return
	 * @see persistence.DAO.DAO#getBeans()
	 */
	@Override
	public List<Bean> getBeans()
	{
		ResultSet rs = null;
		List<Bean> beans = new ArrayList<Bean>();
		try {
			ConnectionManager.getInstance().getConnection();
			rs = selectAll.executeQuery();
			while (rs.next()) {
				Utilisateur util = new Utilisateur();
				util.setId(Integer.parseInt(rs.getString("idUtilisateur")));
				util.setLogin(rs.getString("login"));
				util.setPassword(rs.getString("password"));
				util.setNom(rs.getString("nom"));
				util.setDateNaissance(new java.util.Date(rs.getDate("dateDeNaissance").getTime()));
				util.setEmail(rs.getString("email"));
				util.setNewsletter(rs.getString("newsletter"));
				util.setRang(rs.getString("rang"));
				beans.add(util);
			}
		} catch (SQLException e) {
			LOGGER.error("Erreur lors de la préparation du PreparedStatement");
		} catch (ClassNotFoundException e) {
			LOGGER.error("impossible d'obtenir la connexion");
		}
		return beans;
	}

	/*__________________________________________________________*/
	/**
	 * @param id
	 * @return
	 * @see persistence.DAO.DAO#selectionner(int)
	 */
	@Override
	public Bean selectionner(int id)
	{
		Bean bean = null;
		try {
			ConnectionManager.getInstance().getConnection();
			select.clearParameters();
			select.setInt(1, id);
			ResultSet rs = select.executeQuery();
			while (rs.next()) {
				Utilisateur util = new Utilisateur();
				util.setId(Integer.parseInt(rs.getString("idUtilisateur")));
				util.setLogin(rs.getString("login"));
				util.setPassword(rs.getString("password"));
				util.setNom(rs.getString("nom"));
				util.setDateNaissance(new java.util.Date(rs.getDate("dateDeNaissance").getTime()));
				util.setEmail(rs.getString("email"));
				util.setNewsletter(rs.getString("newsletter"));
				util.setRang(rs.getString("rang"));;
				bean = util;
			}
		} catch (SQLException e) {
			LOGGER.error("Erreur lors de la préparation du PreparedStatement");
		} catch (ClassNotFoundException e) {
			LOGGER.error("impossible d'obtenir la connexion");
		}
		return bean;
	}
	
	
	
	/**
	 * Méthode spécifique à la DAOUser afin de vérifier la présence d'un coup login/password dans la base.
	 */
	public Utilisateur verifier(String userName, String userPwd) {
		Utilisateur user = new Utilisateur();
		try {
			ConnectionManager.getInstance().getConnection();			
			verify.clearParameters();
			verify.setString(1, userName);
			verify.setString(2, userPwd);
			ResultSet rs = verify.executeQuery();
			System.out.println("verify executé");
			while (rs.next()) {
				System.out.println("dans la boucle");
				user.setDateNaissance(new java.util.Date(rs.getDate("dateDeNaissance").getTime()));
				System.out.println("naissance trouvée");
				user.setEmail(rs.getString("email"));
				System.out.println("email trouvé "+rs.getString("email"));
				user.setRang(rs.getString("rang"));
				System.out.println("rang trouvé "+rs.getString("rang"));
				user.setLogin(userName);
				System.out.println("username trouvé "+userName);
				user.setId(Integer.parseInt(rs.getString("idUtilisateur")));
				System.out.println("id trouvé "+rs.getString("idUtilisateur"));
				user.setNom(rs.getString("nom"));
				System.out.println("nom trouvé "+rs.getString("nom"));
				user.setPrenom(rs.getString("prenom"));
				System.out.println("prénom : "+rs.getString("prenom"));
			}
		} catch (SQLException e) {
			LOGGER.error("Erreur dans la requête SQL");
		} catch (ClassNotFoundException e) {
			LOGGER.error("Le driver jdbc n'a pas été trouvé");
		}
		return user;
	}
	
	protected PreparedStatement prepareVerif() throws SQLException,
	ClassNotFoundException
	{
		PreparedStatement ps = null;
		ps = ConnectionManager.getInstance().getConnection().prepareStatement("SELECT * FROM utilisateur WHERE login=? AND password=?");
		return ps;
	}
}
